home *** CD-ROM | disk | FTP | other *** search
/ Just Call Me Internet / Just Call Me Internet.iso / prog / atari / m2 / cat3src / cat / wiedervo.i < prev    next >
Text File  |  1997-10-26  |  27KB  |  905 lines
  1. IMPLEMENTATION MODULE WiederVorlage;
  2.  
  3. FROM SYSTEM  IMPORT ADDRESS, TSIZE, ADR, CADR, CAST, ASSEMBLER;
  4. FROM Storage IMPORT ALLOCATE, DEALLOCATE;
  5.  
  6. IMPORT Strings, StrConv, GrafBase, BinOps, Block;
  7.  
  8. IMPORT MagicAES, MagicDOS, MagicVDI, MagicStrings, mtAppl, mtAlerts, 
  9.        mtUtils;
  10.  
  11. FROM Void         IMPORT v;
  12. FROM ListDl       IMPORT ldElems;
  13.  
  14. IMPORT ListDl;
  15.  
  16. IMPORT CatTypes, data, dataSys, MausTauschrsc, MTE, GroupSelect, CatGlobal, 
  17.        CatHelp, CatFiles, ConvertDate, MTPaths, CatOpts2, grin, 
  18.        QuickSort, ConfVars, Varnames;
  19.  
  20. IMPORT WinDials;
  21.  
  22.  
  23. TYPE    resubRec   = RECORD
  24.                     group : CatTypes.Str255Ptr;
  25.                     msgId : CatTypes.Str255Ptr;
  26.                     from  : CatTypes.Str255Ptr;
  27.                     topic : CatTypes.Str255Ptr;
  28.                     date  : ConvertDate.Date;
  29.                     time  : ConvertDate.Time;
  30.                     resubDate: ConvertDate.Date;
  31.                     selected : BOOLEAN;
  32.                     dataLength: CARDINAL;
  33.                     data  : ADDRESS;
  34.                   END;
  35.                   
  36.         resubPtr = POINTER TO resubRec;
  37.  
  38. CONST   (* Magics fr Header *)
  39.         resubCatMagic     = 43415457H;  (* "CATW"                           *)
  40.         resubVersion      = 1;          (* Versionsnummer der Wiedervorlage *)
  41.         resubVersionMagic = 0100H;      (* Versionsmagic                    *)
  42.  
  43.  
  44. CONST   resubDataName   = 'catresub.dat';
  45.  
  46.         delWVAlt        = "[2][CAT:|Wollen Sie den selektierten|Eintrag wirklich l”schen?][[Ja|:[Nein]";
  47.         doWVAlt1        = "[2][CAT:|Es ";
  48.         doWVMsg0        = "lieg";
  49.         doWVMsg         = " Nachricht";
  50.         doWVAlt2        = " zur|Wiedervorlage vor. Soll die|Erste davon angezeigt werden?][[Ja|:[Nein]";
  51.         
  52. TYPE
  53.     resubHdr = RECORD
  54.                 group,                    (* Offsets in Data hinein, der  *)
  55.                 msgId,
  56.                 from,
  57.                 topic       : CARDINAL;
  58.                 date        : ConvertDate.Date;
  59.                 time        : ConvertDate.Time;
  60.                 resubDate   : ConvertDate.Date;
  61.                 dataLength  : CARDINAL;     (* Die L„nge des folgenden Datenblocks *)
  62.                END;
  63.  
  64. TYPE 
  65.      resubArrayType = ARRAY [0..$7FFF] OF resubRec;
  66.      
  67.      resubArrayPtr  = POINTER TO resubArrayType;
  68.  
  69. VAR listModified: BOOLEAN;
  70.     
  71.     resubArray  : resubArrayPtr;
  72.     maxResubs   : INTEGER;
  73.     resubs      : INTEGER;      (* aktueller Index in Array *)
  74.     globalLength : INTEGER;
  75.     maxLength   : INTEGER;
  76.     currIdx     : INTEGER;
  77.     wvWindow    : INTEGER;
  78.     
  79.     resubForm   : mtUtils.tObjcTree;
  80.     specials    : ARRAY [0..3] OF ListDl.specialButHdler;
  81.     dialHandler : ListDl.ldHandler;
  82.     
  83.  
  84. PROCEDURE MakeNewResubArray (force : BOOLEAN; new : CARDINAL) : BOOLEAN;
  85. (* Alloziert ein neues Gruppenarray und kopiert das alte hinein.
  86.  * FALSE: Nicht genug Speicher!
  87.  *)
  88.  VAR i :  INTEGER;
  89.      newMax : CARDINAL;
  90.      newArray : resubArrayPtr;
  91. BEGIN
  92.   IF (maxResubs = 0) OR (resubs >= maxResubs - 1) OR force
  93.   THEN
  94.     IF force
  95.     THEN
  96.       newMax := new + 20;
  97.     ELSE
  98.       newMax := maxResubs + 20;
  99.     END;
  100.     ALLOCATE (newArray, LONG(newMax) * TSIZE (resubRec));
  101.     IF newArray = NIL
  102.     THEN RETURN FALSE END;
  103.     Block.Clear (newArray, LONG(newMax)*TSIZE(resubRec));
  104.     IF resubArray # NIL 
  105.     THEN
  106.       FOR i := 0 TO INTEGER(maxResubs) - 1 DO newArray^[i] := resubArray^[i] END;
  107.     END;
  108.     DEALLOCATE (resubArray, 0);
  109.     maxResubs := newMax; 
  110.     resubArray := newArray;
  111.   END;
  112.   RETURN TRUE;
  113. END MakeNewResubArray;
  114.  
  115. PROCEDURE MakeEntry (rs: resubPtr; VAR gName, mId, fromL, topicL : ARRAY OF CHAR;
  116.                      dt : ConvertDate.Date; ti: ConvertDate.Time; resubDt : ConvertDate.Date): BOOLEAN;
  117. (* Fllt den Eintrag rs mit den Daten 
  118.  *)
  119. VAR gLen,
  120.     mLen,
  121.     fLen,
  122.     tLen    : INTEGER;
  123.     addLen  : INTEGER;
  124.     target  : ADDRESS;
  125. BEGIN
  126.   (* L„ngen herausfinden *)
  127.   gLen := (*SYSTEM.*)LENGTH (gName);
  128.   mLen := (*SYSTEM.*)LENGTH (mId);
  129.   fLen := (*SYSTEM.*)LENGTH (fromL);
  130.   tLen := (*SYSTEM.*)LENGTH (topicL);
  131.   addLen := gLen + mLen + fLen + tLen + 8;
  132.   (* Jetzt Speicher allozieren *)
  133.   rs^.dataLength := 0;
  134.   ALLOCATE (rs^.data, addLen);
  135.   IF rs^.data = NIL THEN RETURN FALSE END;
  136.   rs^.dataLength := addLen;
  137.   (* Speicher vorhanden, jetzt Eintr„ge setzen *)
  138.   target := rs^.data;
  139.   INC (gLen);
  140.   Block.Copy (ADR(gName), gLen, target);
  141.   rs^.group := target;
  142.   INC (target, gLen);
  143.   IF mLen > 0 THEN
  144.     INC (mLen);
  145.     Block.Copy (ADR(mId), mLen, target);
  146.     rs^.msgId := target;
  147.     INC (target, mLen);
  148.   ELSE
  149.     rs^.msgId := NIL;
  150.   END;
  151.   IF fLen > 0 THEN
  152.     INC (fLen);
  153.     Block.Copy (ADR(fromL), fLen, target);
  154.     rs^.from := target;
  155.     INC (target, fLen);
  156.   ELSE
  157.     rs^.from := NIL
  158.   END;
  159.   IF tLen > 0 THEN
  160.     INC (tLen);
  161.     Block.Copy (ADR(topicL), tLen, target);
  162.     rs^.topic := target;
  163.     INC (target, tLen);
  164.   ELSE
  165.     rs^.topic := NIL
  166.   END;
  167.   rs^.date := dt;
  168.   rs^.time := ti;
  169.   rs^.resubDate := resubDt;
  170.   RETURN TRUE;
  171. END MakeEntry;
  172.  
  173. (*----- Eigene Liste schreiben und lesen ------------------------------*)
  174.  
  175. (* Format der Datei, in der die Liste abgespeichert wird: 
  176.  * Pro Eintrag eine Zeile, die einzelnen Elemente sind getrennt durch ein 
  177.  * TAB-Zeichen (das kommt definitiv nie in Gruppennamen vor).
  178.  * <name>TAB<netname>TAB<chef>TAB<kurztext>TAB<sysopinfo>TAB<followupto>TAB<readNumber>TAB<catNumber>TAB<flags>
  179.  * Dabei werden die Flags wie im ITG gespeichert.
  180.  *)
  181.  
  182. PROCEDURE SaveResubList(): BOOLEAN;
  183.   VAR fname : CatTypes.String255;
  184.       i     : INTEGER;
  185.       dbHdr : dataSys.FileHeaderType;
  186.       fhdl  : INTEGER;
  187.  
  188.   PROCEDURE saveDataEntry (e, i : ADDRESS): BOOLEAN;
  189.     VAR rs    : resubPtr;
  190.         hdr   : resubHdr;
  191.         fPtr  : POINTER TO INTEGER;
  192.   BEGIN
  193.     rs := resubPtr (e);
  194.     fPtr := i;
  195.     WITH hdr DO
  196.       group         := 0;
  197.       msgId         := 0;
  198.       from          := 0;
  199.       topic         := 0;
  200.       IF rs^.msgId    # NIL THEN msgId    := SHORT(LONGCARD(rs^.msgId - rs^.data)) ; END;
  201.       IF rs^.from     # NIL THEN from     := SHORT(LONGCARD(rs^.from - rs^.data)); END;
  202.       IF rs^.topic    # NIL THEN topic    := SHORT(LONGCARD(rs^.topic - rs^.data)); END;
  203.       (* Jetzt die brigen Daten setzen *)
  204.       date       := rs^.date;
  205.       time       := rs^.time      ;
  206.       resubDate  := rs^.resubDate ;   
  207.       dataLength := rs^.dataLength;
  208.     END;
  209.     CatFiles.WriteMuch (TSIZE (resubHdr), fPtr^, ADR(hdr));
  210.     IF CatFiles.FileError # CatFiles.NoError 
  211.     THEN
  212.       RETURN FALSE
  213.     END;
  214.     (* Jetzt die Daten schreiben *)
  215.     CatFiles.WriteMuch (hdr.dataLength, fPtr^, rs^.data);
  216.     RETURN CatFiles.FileError = CatFiles.NoError;
  217.   END saveDataEntry;
  218.   
  219. BEGIN
  220.   MagicStrings.Assign (MTPaths.DataPath, fname);
  221.   MagicStrings.Append (resubDataName, fname);
  222.   listModified := FALSE;
  223.   (* Jetzt das Bin„rfile schreiben *)
  224.   fhdl := CatFiles.CreateFile (MTPaths.DataPath, resubDataName);
  225.   IF fhdl > 0
  226.   THEN
  227.     (* Header schreiben *)
  228.     dbHdr.CatMagic := resubCatMagic;
  229.     dbHdr.Version  := resubVersion;
  230.     dbHdr.VersionMagic := resubVersionMagic;
  231.     CatFiles.WriteMuch (dataSys.dbHeaderLength, fhdl, ADR(dbHdr));
  232.     IF CatFiles.FileError # CatFiles.NoError
  233.     THEN
  234.       MTE.InfoAlert (MTE.noFile1, resubDataName, MTE.noFile4);
  235.       CatFiles.CloseFile (fhdl);
  236.       RETURN FALSE;
  237.     END;
  238.     i := 0;
  239.     WHILE (i < resubs) & 
  240.           saveDataEntry (ADR(resubArray^[i]), ADR(fhdl)) DO INC (i) END;
  241.     CatFiles.CloseFile (fhdl);
  242.     RETURN TRUE;
  243.   ELSE
  244.     (* Fehlermeldung rauswerfen *)
  245.     MTE.InfoAlert (MTE.noFile1, resubDataName, MTE.noFile4);
  246.     RETURN FALSE;
  247.   END;
  248. END SaveResubList;
  249.  
  250. PROCEDURE ReadResubList(): BOOLEAN;
  251.   VAR fname : CatTypes.String255;
  252.       fhdl  : INTEGER;
  253.       lc    : CARDINAL;
  254.  
  255.   PROCEDURE parseData(): BOOLEAN;
  256.     VAR dbHdr   : dataSys.FileHeaderType;
  257.         hdr     : resubHdr;
  258.         rs      : resubPtr;
  259.   BEGIN
  260.     (* Aufbau der CATGROUP.DAT: 
  261.      * fileHeader
  262.      * pro Gruppe:
  263.      * Header
  264.      * Textdaten (variabel)
  265.      *)
  266.     CatFiles.ReadMuch (dataSys.dbHeaderLength, fhdl, ADR(dbHdr));
  267.     IF CatFiles.FileError # CatFiles.NoError
  268.     THEN
  269.       RETURN FALSE
  270.     END;
  271.     (* Jetzt berprfen des Headers *)
  272.     IF (dbHdr.CatMagic # resubCatMagic)
  273.     OR (dbHdr.Version  # resubVersion)
  274.     OR (dbHdr.VersionMagic # resubVersionMagic)
  275.     THEN
  276.       (* Abbrechen *)
  277.       RETURN FALSE
  278.     END;
  279.     (* hier eventuell mal z„hlen, wie viele es denn sind *)
  280.     IF ~MakeNewResubArray (TRUE, 50)
  281.     THEN 
  282.       RETURN FALSE
  283.     END;
  284.     resubs := 0;
  285.     REPEAT
  286.       (* Header lesen *)
  287.       CatFiles.ReadMuch (TSIZE (resubHdr), fhdl, ADR(hdr));
  288.       IF CatFiles.FileError = CatFiles.NoError
  289.       THEN
  290.         (* Ok, Header gelesen *)
  291.         IF ~MakeNewResubArray (FALSE, 0)
  292.         THEN
  293.           RETURN FALSE
  294.         END;
  295.         (* Jetzt Eintrag setzen *)
  296.         rs := ADR (resubArray^[resubs]);
  297.         ALLOCATE (rs^.data, hdr.dataLength);
  298.         IF rs^.data = NIL THEN RETURN FALSE END;
  299.         (* Jetzt Daten kopieren *)
  300.         WITH rs^ DO
  301.           (* Pointer setzen *)
  302.           group := data;
  303.           msgId         := NIL;
  304.           from          := NIL;
  305.           topic         := NIL;
  306.           IF hdr.msgId    # 0 THEN msgId    := data + ADDRESS(LONG(hdr.msgId)); END;
  307.           IF hdr.from     # 0 THEN from     := data + ADDRESS(LONG(hdr.from)); END;
  308.           IF hdr.topic    # 0 THEN topic    := data + ADDRESS(LONG(hdr.topic)); END;
  309.           (* Jetzt die brigen Daten setzen *)
  310.           date       := hdr.date ;
  311.           time       := hdr.time ;
  312.           resubDate  := hdr.resubDate ;   (* F-Zeile *)
  313.           selected   := FALSE  ;          (* Fr Darstellung in Liste, wird beim Einlesen auf FALSE gesetzt *)
  314.           dataLength := hdr.dataLength;   (* Die L„nge des folgenden Datenblocks *)
  315.         END;
  316.         (* Jetzt Daten lesen *)
  317.         CatFiles.ReadMuch (hdr.dataLength, fhdl, rs^.data);
  318.         IF CatFiles.FileError # CatFiles.NoError
  319.         THEN
  320.           (* Lesefehler, abbrechen *)
  321.           RETURN FALSE
  322.         END;
  323.         INC (resubs);
  324.       END;
  325.     UNTIL CatFiles.FileError # CatFiles.NoError;
  326.     RETURN TRUE;
  327.   END parseData;
  328.  
  329.   VAR size  : LONGCARD;
  330.       exists: BOOLEAN;
  331.       
  332.       i     : INTEGER;
  333.  
  334. BEGIN
  335.   mtAppl.MouseOn();
  336.   mtAppl.MouseBusy();
  337.   IF resubArray # NIL THEN DEALLOCATE (resubArray, 0); END;
  338.   resubs := 0;
  339.   maxResubs := 0;
  340.   MagicStrings.Assign (MTPaths.DataPath, fname);
  341.   MagicStrings.Append (resubDataName, fname);
  342.   size := CatFiles.FileSize (fname, exists);
  343.   IF exists & (size > 0) 
  344.   THEN
  345.     fhdl:= CatFiles.OpenFile (MTPaths.DataPath, resubDataName, CatFiles.readFile);
  346.     IF fhdl > 0
  347.     THEN
  348.       IF ~parseData()
  349.       THEN
  350.         IF resubArray # NIL THEN DEALLOCATE (resubArray, 0); END;
  351.         resubs := 0;
  352.         maxResubs := 0;
  353.         CatFiles.CloseFile (fhdl);
  354.         RETURN FALSE;
  355.       ELSE
  356.         CatFiles.CloseFile (fhdl);
  357.         listModified := FALSE;
  358.         mtAppl.MouseArrow();
  359.         RETURN TRUE;
  360.       END;
  361.     END;
  362.   ELSE
  363.     (* Leeres Array anlegen *)
  364.     IF ~MakeNewResubArray (TRUE, 10)
  365.     THEN 
  366.       RETURN FALSE
  367.     END;
  368.     resubs := 0;
  369.   END;
  370.   RETURN TRUE;
  371. END ReadResubList;
  372.  
  373. PROCEDURE DeleteEntry (idx: INTEGER);
  374.   VAR i : INTEGER;
  375. BEGIN
  376.   IF (idx < 0) OR (idx >= resubs) THEN RETURN END;
  377.   FOR i := idx+1 TO resubs-1 DO
  378.     (* Eintr„ge runterkopieren *)
  379.     resubArray^[i-1] := resubArray^[i];
  380.   END;
  381.   DEC (resubs);
  382.   listModified := TRUE;
  383. END DeleteEntry;
  384.  
  385. PROCEDURE sortDate (e1, e2: ADDRESS): BOOLEAN;
  386.   VAR pResub1, pResub2: resubPtr;
  387. BEGIN
  388.   pResub1 := e1;
  389.   pResub2 := e2;
  390.   RETURN ConvertDate.PackDate (pResub1^.resubDate) < ConvertDate.PackDate (pResub2^.resubDate);
  391. END sortDate;
  392.  
  393. PROCEDURE SortResubs();
  394. BEGIN
  395.   v.bool := QuickSort.sortIt (0, resubs-1, resubArray^, sortDate, 
  396.                               TSIZE (resubRec), QuickSort.noBreak);
  397. END SortResubs;
  398.  
  399. (*----------------------------------------------------------------------
  400.  * "Listen"prozeduren
  401.  *----------------------------------------------------------------------*)
  402.  
  403. PROCEDURE BuildLine1 (entry: ADDRESS; VAR str: ARRAY OF CHAR);
  404.   VAR pResub : resubPtr;
  405. BEGIN
  406.   pResub := entry;
  407.   WITH pResub^ DO
  408.     IF from # NIL
  409.     THEN 
  410.       CatGlobal.KurzName (from^, str, 25);
  411.     ELSE
  412.       CatGlobal.KurzName ("Anonym", str, 25);
  413.     END;
  414.     MagicStrings.Append ("  ", str);
  415.     IF group # NIL THEN 
  416.       MagicStrings.Append (group^, str);
  417.     END;
  418.     MagicStrings.Append (" ", str);
  419.   END;
  420. END BuildLine1;
  421.  
  422. PROCEDURE BuildLine2 (entry: ADDRESS; VAR str: ARRAY OF CHAR);
  423.   VAR pResub : resubPtr;
  424.       tmpStr : ARRAY [0..39] OF CHAR;
  425. BEGIN
  426.   pResub := entry;
  427.   WITH pResub^ DO
  428.     MagicStrings.Assign ("  Wv: ", str);
  429.     ConvertDate.DateToText (resubDate, "DD.MM.YY", tmpStr);
  430.     MagicStrings.Append (tmpStr, str);
  431.     MagicStrings.Append ("  Vom: ", str);
  432.     ConvertDate.DateToText (date, "DD.MM.YY", tmpStr);
  433.     MagicStrings.Append (tmpStr, str);
  434.     MagicStrings.Append ("  ", str);
  435.     IF topic # NIL THEN
  436.       MagicStrings.Append (topic^, str);
  437.     END;
  438.     MagicStrings.Append (" ", str);
  439.   END;
  440. END BuildLine2;
  441.  
  442. PROCEDURE CountEntries ( l : ADDRESS; VAR ll: LONGINT; VAR ww: INTEGER);
  443. BEGIN
  444.  ww := globalLength*mtAppl.CharWidth;
  445.  ll := LONG (resubs);
  446. END CountEntries;
  447.  
  448. PROCEDURE NextEntry ( l : ADDRESS) : ADDRESS;
  449. BEGIN
  450.  IF currIdx < resubs
  451.  THEN
  452.    INC (currIdx);
  453.    RETURN ADR(resubArray^[currIdx-1]);
  454.  ELSE
  455.    RETURN NIL;
  456.  END;
  457. END NextEntry;
  458.  
  459. PROCEDURE PrevEntry ( l : ADDRESS) : ADDRESS;
  460. BEGIN
  461.  IF currIdx > 0 
  462.  THEN
  463.    DEC (currIdx);
  464.    RETURN ADR(resubArray^[currIdx]);
  465.  ELSE
  466.    RETURN NIL;
  467.  END;
  468. END PrevEntry;
  469.  
  470. PROCEDURE ResetResubs (l: ADDRESS);
  471. BEGIN
  472.   currIdx := 0;
  473. END ResetResubs;
  474.  
  475. PROCEDURE resubToStr (entry, env : ADDRESS; VAR str : ARRAY OF CHAR);
  476. END resubToStr;
  477.  
  478. PROCEDURE selEntry (entry, env : ADDRESS; line : INTEGER) : BOOLEAN;
  479.  VAR e : resubPtr;
  480.      str : ARRAY [0..255] OF CHAR;
  481. BEGIN
  482.   e := entry;
  483.   IF e = NIL THEN RETURN FALSE END;
  484.   e^.selected := ~e^.selected;
  485.   RETURN FALSE
  486. END selEntry;
  487.  
  488. PROCEDURE isSelected (entry, env : ADDRESS) : BOOLEAN;
  489.   VAR ent : resubPtr;
  490. BEGIN
  491.   ent := entry;
  492.   RETURN ent^.selected;
  493. END isSelected;
  494.  
  495. PROCEDURE isEnabled (adr : ADDRESS; env : ADDRESS) : BOOLEAN;
  496. BEGIN
  497.   RETURN TRUE
  498. END isEnabled;
  499.  
  500. (*----------------------------------------------------------------------
  501.  * Userinterface
  502.  *----------------------------------------------------------------------*)
  503.  
  504. PROCEDURE UpdateButtonWV (entry, env : ADDRESS);
  505.   VAR oneSel : BOOLEAN;
  506.       changed: BOOLEAN;
  507.       i      : INTEGER;
  508. BEGIN
  509.   (* selektieren Eintrag finden *)
  510.   i := 0;
  511.   WHILE (i < resubs) & ~resubArray^[i].selected DO
  512.     INC (i);
  513.   END;
  514.   oneSel := i < resubs;
  515.   changed := mtUtils.InState (resubForm, MausTauschrsc.wvdel, MagicAES.DISABLED);
  516.  
  517.   changed := changed # (~oneSel);
  518.  
  519.   IF changed
  520.   THEN
  521.     mtUtils.SetState (resubForm, MausTauschrsc.wvdel, MagicAES.DISABLED, ~oneSel);
  522.     mtUtils.SetState (resubForm, MausTauschrsc.wvread, MagicAES.DISABLED, ~oneSel);
  523.     mtUtils.SetState (resubForm, MausTauschrsc.wvchange, MagicAES.DISABLED, ~oneSel);
  524.     WinDials.WinDialDraw (resubForm, MausTauschrsc.wvdel, 0, v.r, FALSE);
  525.     WinDials.WinDialDraw (resubForm, MausTauschrsc.wvread, 0, v.r, FALSE);
  526.     WinDials.WinDialDraw (resubForm, MausTauschrsc.wvchange, 0, v.r, FALSE);
  527.   END;
  528. END UpdateButtonWV;
  529.  
  530. PROCEDURE HelpWV (obj : INTEGER; env, env2: ADDRESS; VAR draw, exit : BOOLEAN);
  531. BEGIN
  532.   CatHelp.DoHelp (CatHelp.wvhelp);
  533.   mtUtils.ExclState (resubForm, obj, MagicAES.SELECTED);
  534.   WinDials.WinDialDraw (resubForm, obj, 0, v.r, FALSE);
  535.   exit := FALSE;
  536.   draw := FALSE;
  537. END HelpWV;
  538.  
  539. PROCEDURE getIdNumber(ptr : data.OneGroupHandle):CARDINAL;
  540. BEGIN
  541.   RETURN data.NumberOfID(ptr, resubArray^[currIdx].msgId^);
  542. END getIdNumber;
  543.  
  544. PROCEDURE OpenWV (obj : INTEGER; env, env2: ADDRESS; VAR draw, exit : BOOLEAN);
  545.   VAR oneSel    : BOOLEAN;
  546.       i         : INTEGER;
  547.       gruppe    : CARDINAL;
  548. BEGIN
  549.   (* selektieren Eintrag finden *)
  550.   i := 0;
  551.   WHILE (i < resubs) & ~resubArray^[i].selected DO
  552.     INC (i);
  553.   END;
  554.   oneSel := i < resubs;
  555.   IF oneSel
  556.   THEN
  557.     currIdx := i;
  558.     IF GroupSelect.GroupNumber (resubArray^[currIdx].group^, gruppe)
  559.     THEN
  560.       IF wvWindow > 0
  561.       THEN
  562.         IF ~grin.grinSwitchToMess (wvWindow, gruppe, getIdNumber)
  563.         THEN
  564.           wvWindow := -1;
  565.           wvWindow := grin.grinOpenWithProc (gruppe, getIdNumber, grin.grinNextMess, 0, grin.mOther);
  566.         END;
  567.       ELSE
  568.         wvWindow := grin.grinOpenWithProc (gruppe, getIdNumber, grin.grinNextMess, 0, grin.mOther);
  569.       END;
  570.     END;
  571.   END;
  572.   mtUtils.ExclState (resubForm, obj, MagicAES.SELECTED);
  573.   WinDials.WinDialDraw (resubForm, obj, 0, v.r, FALSE);
  574.   exit := FALSE;
  575.   draw := FALSE;
  576. END OpenWV;
  577.  
  578. PROCEDURE ChangeWV (obj : INTEGER; env, env2: ADDRESS; VAR draw, exit : BOOLEAN);
  579.   VAR theDate   : ARRAY [0..39] OF CHAR;
  580.       oneSel    : BOOLEAN;
  581.       i         : INTEGER;
  582. BEGIN
  583.   (* selektieren Eintrag finden *)
  584.   i := 0;
  585.   WHILE (i < resubs) & ~resubArray^[i].selected DO
  586.     INC (i);
  587.   END;
  588.   oneSel := i < resubs;
  589.   draw := FALSE;
  590.   IF oneSel
  591.   THEN
  592.     ConvertDate.DateToText (resubArray^[i].resubDate, "dd.mm.YYYY", theDate);
  593.     IF CatOpts2.DatumHolen (TRUE, theDate)
  594.     THEN
  595.       ConvertDate.TextToDate (theDate, resubArray^[i].resubDate, v.bool);
  596.       listModified := TRUE;
  597.       draw := TRUE;
  598.       SortResubs();
  599.     END;
  600.   END;  
  601.   mtUtils.ExclState (resubForm, obj, MagicAES.SELECTED);
  602.   WinDials.WinDialDraw (resubForm, obj, 0, v.r, FALSE);
  603.   exit := FALSE;
  604. END ChangeWV;
  605.  
  606. PROCEDURE DeleteWV (obj : INTEGER; env, info: ADDRESS; VAR draw, exit : BOOLEAN);
  607.   VAR oneSel    : BOOLEAN;
  608.       i         : INTEGER;
  609. BEGIN
  610.   draw := FALSE;
  611.   (* selektieren Eintrag finden *)
  612.   i := 0;
  613.   WHILE (i < resubs) & ~resubArray^[i].selected DO
  614.     INC (i);
  615.   END;
  616.   oneSel := i < resubs;
  617.   IF oneSel
  618.   THEN
  619.     v.int := mtAlerts.Alert (1, delWVAlt);
  620.     IF v.int = 1
  621.     THEN
  622.       DeleteEntry (i);
  623.       draw := TRUE;
  624.     END;
  625.   END;
  626.   mtUtils.ExclState (resubForm, obj, MagicAES.SELECTED);
  627.   WinDials.WinDialDraw (resubForm, obj, 0, v.r, FALSE);
  628.   exit := FALSE;
  629. END DeleteWV;
  630.  
  631. PROCEDURE drawResubEntry (entry, env : ADDRESS; x, y : INTEGER;
  632.                           offset : INTEGER; clip   : GrafBase.Rectangle);
  633.  
  634.    VAR e   : resubPtr;
  635.        str : ARRAY [0..255] OF CHAR;
  636.        eff : BITSET;
  637.        fillcol : INTEGER;
  638.        fill: GrafBase.Rectangle;
  639.        isSel: BOOLEAN;
  640. BEGIN
  641.   e := entry;
  642.  
  643.   fill.x := x;
  644.   fill.y := y;
  645.   fill.w := fill.x + globalLength*mtAppl.CharWidth-1;
  646.   fill.h := fill.y + 2*mtAppl.CharHeight -1 ;
  647.  
  648.   clip.w := clip.x+clip.w-1;
  649.   clip.h := clip.y+clip.h-1;
  650.  
  651.   MagicVDI.SetClipping (mtAppl.PrivateWS, clip, TRUE);
  652.   v.int := MagicVDI.SetWritemode (mtAppl.PrivateWS, MagicVDI.REPLACE);
  653.   fillcol := 0;
  654.   isSel := FALSE;
  655.   IF (e # NIL) & isSelected (entry, env)
  656.   THEN
  657.     fillcol := 1; 
  658.     isSel := TRUE;
  659.   END;
  660.   mtAppl.MouseOff();
  661.   v.int := MagicVDI.SetFillcolor (mtAppl.PrivateWS, fillcol);
  662.   MagicVDI.FillRectangle (mtAppl.PrivateWS, fill);
  663.   IF e # NIL
  664.   THEN
  665.     eff := {};
  666.     IF ~isEnabled (entry, env)
  667.     THEN
  668.       INCL (eff, MagicVDI.Light);
  669.     END;
  670.     IF ConvertDate.PackDate (e^.resubDate) = MagicDOS.Tgetdate()
  671.     THEN
  672.       INCL (eff, MagicVDI.Fat);
  673.     END;
  674.     IF isSel
  675.     THEN
  676.       v.int := MagicVDI.SetWritemode (mtAppl.PrivateWS, MagicVDI.XOR);
  677.     END;
  678.  
  679.     (* Jetzt hier den String fr den Gruppennamen zusammenbauen *)
  680.     BuildLine1 (e, str);
  681.  
  682.     eff:= MagicVDI.SetTexteffect (mtAppl.PrivateWS, eff);
  683.     MagicVDI.Text (mtAppl.PrivateWS, x, y, str);
  684.     INC (y, mtAppl.CharHeight);
  685.     
  686.     BuildLine2 (e, str);
  687.     MagicVDI.Text (mtAppl.PrivateWS, x, y, str);
  688.     
  689.     eff:= MagicVDI.SetTexteffect (mtAppl.PrivateWS, {});
  690.     v.int := MagicVDI.SetWritemode (mtAppl.PrivateWS, MagicVDI.REPLACE);
  691.   END;
  692.   MagicVDI.SetClipping (mtAppl.PrivateWS, clip, FALSE);
  693.   mtAppl.MouseOn();
  694. END drawResubEntry;
  695.  
  696. PROCEDURE setAndGetResubValues (tree: ADDRESS; private: ADDRESS; set: BOOLEAN; exitBut: INTEGER);
  697.   VAR i : INTEGER;
  698.       gruppe: CARDINAL;  
  699. BEGIN
  700.   IF set
  701.   THEN
  702.     wvWindow := -1;
  703.     FOR i := 0 TO resubs - 1 DO
  704.       resubArray^[i].selected := FALSE;
  705.     END;
  706.     mtUtils.SetState (resubForm, MausTauschrsc.wvdel, MagicAES.DISABLED, TRUE);
  707.     mtUtils.SetState (resubForm, MausTauschrsc.wvread, MagicAES.DISABLED, TRUE);
  708.     mtUtils.SetState (resubForm, MausTauschrsc.wvchange, MagicAES.DISABLED, TRUE);
  709.   ELSE
  710.     IF exitBut # MausTauschrsc.wvcancel
  711.     THEN
  712.       IF listModified
  713.       THEN
  714.         v.bool := SaveResubList();
  715.       END;
  716.       (*
  717.       IF exitBut = MausTauschrsc.wvread
  718.       THEN
  719.         (* Selektierten Eintrag ”ffnen *)
  720.         IF GroupSelect.GroupNumber (resubArray^[currIdx].group^, gruppe)
  721.         THEN
  722.           v.int := grin.grinOpenWithProc (gruppe, getIdNumber, grin.grinNextMess, 0, grin.mOther);
  723.         END;
  724.       END;
  725.       *)
  726.     ELSE
  727.       IF listModified
  728.       THEN
  729.         (* Žnderungen verwerfen und einfach neu laden *)
  730.         IF resubArray # NIL THEN DEALLOCATE (resubArray, 0); END;
  731.         maxResubs := 0;
  732.         resubs := 0;
  733.         v.bool := ReadResubList();
  734.       END;
  735.     END;
  736.   END;
  737. END setAndGetResubValues;
  738.  
  739. PROCEDURE SelectResub();
  740. VAR maxLength: INTEGER;
  741.     r        : GrafBase.Rectangle;
  742.     str      : ARRAY [0..255] OF CHAR;
  743.     i        : INTEGER;
  744.  
  745. BEGIN
  746.   (* Jetzt das Object zusammenbauen *)
  747.   resubForm := MausTauschrsc.TreeAddr^[MausTauschrsc.wvform];
  748.  
  749.   IF WinDials.IsWinDial (resubForm)
  750.   THEN
  751.     (* Fenster toppen und rausgehen *)
  752.     WinDials.ActivateWinDial (resubForm);
  753.     RETURN;
  754.   END;
  755.   (* Maximale Breite eines Listeneintrages herausfinden *)
  756.   maxLength := 0;
  757.   FOR i := 0 TO resubs-1 DO
  758.     BuildLine1 (ADR(resubArray^[i]), str);
  759.     maxLength := BinOps.HigherInt (INTEGER(LENGTH(str)), maxLength);
  760.     BuildLine2 (ADR(resubArray^[i]), str);
  761.     maxLength := BinOps.HigherInt (INTEGER(LENGTH(str)), maxLength);
  762.     resubArray^[i].selected := FALSE;
  763.   END;
  764.  
  765.   
  766.   mtUtils.CalcArea (resubForm, MausTauschrsc.wvbox, r);
  767.   maxLength := BinOps.HigherInt (maxLength, r.w DIV mtAppl.CharWidth);
  768.   
  769.   globalLength := maxLength;
  770.  
  771.   (* specials bestimmen *)
  772.   specials[0].objc := MausTauschrsc.wvchange;
  773.   specials[0].proc := ChangeWV;
  774.   specials[1].objc := MausTauschrsc.wvdel;
  775.   specials[1].proc := DeleteWV;
  776.   specials[2].objc := MausTauschrsc.wvhelp;
  777.   specials[2].proc := HelpWV;
  778.   specials[3].objc := MausTauschrsc.wvread;
  779.   specials[3].proc := OpenWV;
  780.  
  781.   mtUtils.SetState (resubForm, MausTauschrsc.wvdel, MagicAES.DISABLED, TRUE);
  782.   mtUtils.SetState (resubForm, MausTauschrsc.wvread, MagicAES.DISABLED, TRUE);
  783.   mtUtils.SetState (resubForm, MausTauschrsc.wvchange, MagicAES.DISABLED, TRUE);
  784.  
  785.   (* WindowDialog vorbereiten *)
  786.   ListDl.BuildLdHandler (resubArray, ResetResubs, NextEntry, PrevEntry,
  787.                   CountEntries, isEnabled, selEntry,
  788.                   resubToStr, isSelected, drawResubEntry,
  789.                   0, 2*mtAppl.CharHeight, 
  790.                   8, globalLength*mtAppl.CharWidth,
  791.                   dialHandler);
  792.   (* ListWinDialog ”ffnen *)
  793.   IF ListDl.WinListDial (resubForm, ListDl.ldElemSet{ldSelect, ldArrows, ldDoubleExit},
  794.                   dialHandler,
  795.                   MausTauschrsc.wvbox,
  796.                   MausTauschrsc.wvback,
  797.                   MausTauschrsc.wvok,
  798.                   MausTauschrsc.wvcancel,
  799.                   NIL, MausTauschrsc.wvread,
  800.                   -1,
  801.                   UpdateButtonWV,
  802.                   specials,
  803.                   4,
  804.                   ListDl.dummyCheckExit,
  805.                   setAndGetResubValues,
  806.                   setAndGetResubValues,
  807.                   v.a)
  808.   THEN
  809.   END;
  810. END SelectResub;
  811.  
  812. PROCEDURE AddResub (VAR group, msgId, from, topic: ARRAY OF CHAR;
  813.                     tDate: LONGCARD);
  814.   VAR dt, rsDate    : ConvertDate.Date;
  815.       ti            : ConvertDate.Time;
  816.       theDate       : ARRAY [0..39] OF CHAR;
  817. BEGIN
  818.   (* Datum konvertieren *)
  819.   ConvertDate.CatDate2Datim (tDate, dt, ti);
  820.   MagicStrings.Assign ("", theDate);
  821.   IF CatOpts2.DatumHolen (TRUE, theDate)
  822.   THEN
  823.     ConvertDate.TextToDate (theDate, rsDate, v.bool);
  824.     IF ~MakeNewResubArray (FALSE, 0)
  825.     THEN
  826.       MTE.noMemAlert();
  827.       RETURN 
  828.     END;
  829.     (* Jetzt Eintrag setzen *)
  830.     IF ~MakeEntry (ADR (resubArray^[resubs]), group, msgId, from, topic,
  831.                    dt, ti, rsDate)
  832.     THEN
  833.       MTE.noMemAlert();
  834.     ELSE
  835.       INC (resubs);
  836.       SortResubs();
  837.       v.bool := SaveResubList();
  838.     END;
  839.   END;
  840. END AddResub;
  841.  
  842. PROCEDURE CheckForResub ();
  843.   VAR today: CARDINAL;
  844.       checkDate: CARDINAL;
  845.       lastDate : ConvertDate.Date;
  846.       i, 
  847.       count: INTEGER; 
  848.       gruppe: CARDINAL;
  849.       tmp   : ARRAY [0..19] OF CHAR;
  850.       alertStr  : CatTypes.String255;
  851. BEGIN
  852.   today := MagicDOS.Tgetdate();
  853.   count := 0;
  854.   checkDate := today;
  855.   IF ConfVars.GetConfigString (cLastResub, alertStr)
  856.   THEN
  857.     ConvertDate.TextToDate (alertStr, lastDate, v.bool);
  858.     IF v.bool
  859.     THEN
  860.       checkDate := ConvertDate.PackDate (lastDate);
  861.       IF checkDate = today THEN RETURN END;
  862.     END;
  863.   END;
  864.   (* Datum abspeichern *)
  865.   lastDate := ConvertDate.UnpackDate (today);
  866.   ConvertDate.DateToText (lastDate, "DD.MM.YYYY", alertStr);
  867.   v.bool := ConfVars.SetConfigString (cLastResub, alertStr);
  868.   (* Jetzt prfen *)
  869.   FOR i := 0 TO resubs - 1 DO
  870.     IF (ConvertDate.PackDate(resubArray^[i].resubDate) >= checkDate)
  871.      & (ConvertDate.PackDate(resubArray^[i].resubDate) <=  today)
  872.     THEN
  873.       IF count = 0 
  874.       THEN 
  875.         currIdx := i;
  876.       END;
  877.       INC (count);
  878.     END;
  879.   END;
  880.   IF count > 0
  881.   THEN
  882.     MagicStrings.Assign (doWVAlt1, alertStr);
  883.     CatGlobal.Konjugiere (doWVMsg0, "t ", "en ", count, tmp);
  884.     MagicStrings.Append (tmp, alertStr);
  885.     MagicStrings.Append (StrConv.IntToStr (count, 0), alertStr);
  886.     CatGlobal.Konjugiere (doWVMsg, "", "en", count, tmp);
  887.     MagicStrings.Append (tmp, alertStr);
  888.     MagicStrings.Append (doWVAlt2, alertStr);
  889.     v.int := mtAlerts.Alert (1, alertStr);
  890.     IF v.int = 1
  891.     THEN
  892.       (* Selektierten Eintrag ”ffnen *)
  893.       IF GroupSelect.GroupNumber (resubArray^[currIdx].group^, gruppe)
  894.       THEN
  895.         v.int := grin.grinOpenWithProc (gruppe, getIdNumber, grin.grinNextMess, 0, grin.mOther);
  896.       END;
  897.     END;
  898.   END;
  899. END CheckForResub;
  900.  
  901. BEGIN
  902.   resubArray := NIL;
  903.   resubs := 0;
  904. END WiederVorlage.
  905.